
package com.zw.admin.server.utils;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * @author shenhui.yang
 * @version 1.0.0
 * @ClassName DateUtils2
 * @Description 时间工具类
 * @date 2015年11月16日 下午4:11:24
 */
public class DateUtils2 {
    private static final Logger LOGGER = LoggerFactory.getLogger(DateUtils2.class);
    /**
     * 英文简写(默认)如:2010/12/01
     */
    public static final String FORMAT_STAND = "yyyy/MM/dd";

    /**
     * 英文简写(默认)如:2010-12-01
     */
    public static final String FORMAT_SHORT = "yyyy-MM-dd";

    /**
     * 英文全称如:2010-12-01 23:15:06
     */
    public static final String FORMAT_LONG = "yyyy-MM-dd HH:mm:ss";
    /**
     * 英文全称如:2010-12-01 23:15:06
     */
    public static final String FORMAT_LONG_1 = "yyyy/MM/dd HH:mm:ss";

    /**
     * 类似于Fri Dec 04 11:20:42 CST 2015的时间格式
     */
    public static final String FORMAT_CST = "EEE MMM dd HH:mm:ss zzz yyyy";
    /**
     * 精确到毫秒的完整时间如:yyyy-MM-dd HH:mm:ss.S
     */
    public static final String FORMAT_FULL = "yyyy-MM-dd HH:mm:ss.S";
    /**
     * 中文简写如:2010年12月01日
     */
    public static final String FORMAT_SHORT_CN = "yyyy年MM月dd日";
    /**
     * 中文全称如:2010年12月01日 23时15分06秒
     */
    public static final String FORMAT_LONG_CN = "yyyy年MM月dd日 HH时mm分ss秒";
    /**
     * 精确到毫秒的完整中文时间
     */
    public static final String FORMAT_FULL_CN = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒";

    public static final String FORMAT_SHORT2 = "yyyyMMdd";
    
    /**
     * 获得默认的date pattern
     *
     * @return
     */
    public static String getDatePattern() {
        return FORMAT_LONG;
    }

    /**
     * 根据预设格式返回当前日期
     *
     * @return String
     */
    public static String getNow() {
        return format(new Date());
    }

    /**
     * 根据用户格式返回当前日期
     *
     * @param format
     * @return String
     */
    public static String getNow(String format) {
        return format(new Date(), format);
    }

    /**
     * 使用预设格式格式化日期
     *
     * @param date
     * @return String
     */
    public static String format(Date date) {
        return format(date, getDatePattern());
    }

    /**
     * 使用用户格式格式化日期
     *
     * @param date    日期
     * @param pattern 日期格式
     * @return String
     */
    public static String format(Date date, String pattern) {
        String returnValue = "";
        if (date != null) {
            SimpleDateFormat df = new SimpleDateFormat(pattern);
            returnValue = df.format(date);
        }
        return returnValue;
    }

    /**
     * 使用预设格式提取字符串日期
     *
     * @param strDate 日期字符串
     * @return Date
     */
    public static Date parse(String strDate) {
        return parse(strDate, getDatePattern());
    }

    /**
     * 根据退订中的时间格式转化为yyyy-MM-dd HH:mm:ss的标准时间格式
     * parseReturnTime
     *
     * @param returnTime
     * @return String
     * @throws
     * @since 1.0.0
     */
    public static String parseReturnTime(String returnTime) {
        if (!StringUtils.isBlank(returnTime)) {

            SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_LONG);
            SimpleDateFormat sdf1 = null;
            SimpleDateFormat sdf2 = null;

            if (returnTime.contains("CST")) {
                sdf1 = new SimpleDateFormat(FORMAT_CST, Locale.US);
                try {
                    return sdf.format(sdf1.parse(returnTime));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            } else {
                sdf2 = new SimpleDateFormat(FORMAT_LONG_1);
                try {
                    return sdf.format(sdf2.parse(returnTime));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    /**
     * 使用用户格式提取字符串日期
     *
     * @param strDate 日期字符串
     * @param pattern 日期格式
     * @return Date
     */
    public static Date parse(String strDate, String pattern) {
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        try {
            return df.parse(strDate);
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 在日期上增加数个整月
     *
     * @param date 日期
     * @param n    要增加的月数
     * @return Date
     */
    public static Date addMonth(Date date, int n) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, n);
        return cal.getTime();
    }

    /**
     * 在日期上增加天数
     *
     * @param date 日期
     * @param n    要增加的天数
     * @return Date
     */
    public static Date addDay(Date date, int n) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DATE, n);
        return cal.getTime();
    }

    /**
     * 在日期上增加小时
     * addDay
     *
     * @param date 日期
     * @param n    要增加的小时
     * @return Date
     * @throws
     * @since 1.0.0
     */
    public static Date addHour(Date date, int n) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.HOUR, n);
        return cal.getTime();
    }

    /**
     * 获取时间戳
     *
     * @return String
     */
    public static String getTimeString() {
        SimpleDateFormat df = new SimpleDateFormat(FORMAT_FULL);
        Calendar calendar = Calendar.getInstance();
        return df.format(calendar.getTime());
    }

    /**
     * 获取日期年份
     *
     * @param date 日期
     * @return String
     */
    public static String getYear(Date date) {
        return format(date).substring(0, 4);
    }

    /**
     * 按默认格式的字符串距离今天的天数
     *
     * @param date 日期字符串
     * @return int
     */
    public static int countDays(String date) {
        long t = Calendar.getInstance().getTime().getTime();
        Calendar c = Calendar.getInstance();
        c.setTime(parse(date));
        long t1 = c.getTime().getTime();
        return (int) (t / 1000 - t1 / 1000) / 3600 / 24;
    }

    /**
     * 按用户格式字符串距离今天的天数
     *
     * @param date   日期字符串
     * @param format 日期格式
     * @return int
     */
    public static int countDays(String date, String format) {
        long t = Calendar.getInstance().getTime().getTime();
        Calendar c = Calendar.getInstance();
        c.setTime(parse(date, format));
        long t1 = c.getTime().getTime();
        return (int) (t / 1000 - t1 / 1000) / 3600 / 24;
    }

    /**
     * 根据毫秒数返回日期格式
     * getTimeByLong
     *
     * @param date
     * @return String
     * @throws
     * @since 1.0.0
     */
    public static String getTimeByLong(long date) {
        Date d = new Date(date);
        SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_LONG);
        return sdf.format(d);
    }

    /**
     * 根据毫秒数返回日期格式
     * getTimeByLong
     *
     * @param date
     * @param format 日期格式例如:yyyy-MM-dd HH:mm:ss
     * @return String
     * @throws
     * @since 1.0.0
     */
    public static String getTimeByLong(long date, String format) {
        Date d = new Date(date);
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(d);
    }


    /**
     * 在日期上增加分钟
     *
     * @param date 日期
     * @param n    要增加的分钟
     * @return Date
     */
    public static Date addMinute(Date date, int n) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MINUTE, n);
        return cal.getTime();
    }


    /**
     * 通过时间判断改成今天，昨天
     *
     * @param date
     * @return
     */
    public static String converDateToChinese(String date) {
        Date today = new Date();
        Date yesterday = DateUtils2.addDay(today, -1);
        Date beforeyesday = DateUtils2.addDay(today, -2);

        String result = date;

        String todayStr = DateUtils2.format(today, DateUtils2.FORMAT_SHORT);
        String yesterdayStr = DateUtils2.format(yesterday, DateUtils2.FORMAT_SHORT);
        String beforeyesdayStr = DateUtils2.format(beforeyesday, DateUtils2.FORMAT_SHORT);

        if (date.equals(todayStr)) {
            result = "今天";
        } else if (date.equals(yesterdayStr)) {
            result = "昨天";
        } else if (date.equals(beforeyesdayStr)) {
            result = "前天";
        } else {
            result = date.split("-")[1] + "月" + date.split("-")[2] + "日";
        }

        return result;
    }

    /**
     * 日期转化为时间戳
     *
     * @param date   日期
     * @param format 格式
     * @return 时间戳
     */
    public static long dateCovertTimeLong(String date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        long time = 0L;
        try {
            Date d = sdf.parse(date);
            time = d.getTime();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    /**
     * 日期转化为时间戳(10位长度)
     *
     * @param date   日期
     * @param format 格式
     * @return 时间戳
     */
    public static long dateCovertTimeInt10(String date, String format) {
        return dateCovertTimeLong(date, format) / 1000;
    }

    /**
     * 根据指定的pattern精度判断两个日期大小
     *
     * @param date1
     * @param date2
     * @param pattern
     * @return 1：date1>date2 0:date1=date2 -1:date1<date2
     */
    public static int compareDateByPattern(Date date1, Date date2, String pattern) {
        if (StringUtils.isNotBlank(pattern)) {
            date1 = parse(format(date1, pattern), pattern);
            date2 = parse(format(date2, pattern), pattern);
        }

        if (date1.getTime() > date2.getTime()) {
            return 1;
        } else if (date1.getTime() == date2.getTime()) {
            return 0;
        } else {
            return -1;
        }
    }

    /**
     * 时间戳转换为日期
     *
     * @param time   时间戳
     * @param format 日期格式
     * @return
     */
    public static String timeConvertDate(long time, String format) {
        if (String.valueOf(time).length() == 10) {
            time *= 1000;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(new Date(time));
    }

    /**
     * 字符串时间戳转换为日期
     *
     * @param time
     * @param format
     * @return
     */
    public static String timeConvertDate(String time, String format) {
        if (StringUtils.isBlank(time)) {
            return "";
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        long timeLong = Long.parseLong(time);
        return sdf.format(new Date(timeLong));
    }

    /**
     * 判断当前时间是否在指定时间段内（只能判断小时）
     *
     * @return
     */
    public static boolean checkInTime(Calendar cal, int startHour, int endHour) {
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        if (hour >= startHour && hour < endHour) {
            return true;
        }
        return false;
    }

    /**
     * 判断两个秒数相差几天
     *
     * @param time1
     * @param time2
     * @return
     */
    public static long differDays(long time1, long time2) {
        Date date1 = new Date(time1 * 1000L);
        Date date2 = new Date(time2 * 1000L);
        long date1Start = DateUtils2.parse(DateUtils2.format(date1, DateUtils2.FORMAT_SHORT), DateUtils2.FORMAT_SHORT).getTime();
        long date2Start = DateUtils2.parse(DateUtils2.format(date2, DateUtils2.FORMAT_SHORT), DateUtils2.FORMAT_SHORT).getTime();
        long differDays = (date1Start - date2Start) / (24 * 3600 * 1000L);

        return differDays;
    }
    
    /**
     * 判断两个日期相差几天
     * <B>Description:</B> <br>
     * <B>Create on:</B> 2020年2月17日 上午11:58:42<br>
     *
     * @param date1
     * @param date2
     * @return 
     * @author yingjie.shen
     */
    public static long differDays(Date date1, Date date2) {
        return differDays(date1.getTime()/1000L, date2.getTime()/1000L);
    }

    /**
     * 获得当前时间戳
     *
     * @return
     */
    public static long getNowTime() {
        return System.currentTimeMillis();
    }

    /**
     * 获得当前时间戳10位
     *
     * @return
     */
    public static long getNowTime10() {
        return getNowTime() / 1000;
    }

    /**
     * 日期比较
     *
     * @param date1  字符串日期格式 F: 2018-01-30
     * @param date2  字符串日期格式F: 2018-01-29
     * @param format 日期格式
     * @return =0:相等, >0:大于, <0:小于
     */
    public static int compareTo(String date1, String date2, String format) {
        DateFormat df = new SimpleDateFormat(format);
        Calendar date1Time = Calendar.getInstance();
        Calendar date2Time = Calendar.getInstance();
        try {
            //把字符串转成日期类型
            date1Time.setTime(df.parse(date1));
            date2Time.setTime(df.parse(date2));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return date1Time.compareTo(date2Time);
    }

    /**
     * <B>Description:</B>校验是否满足特殊格式的时间字符串<br>
     * <B>Create on:</B> 2018/9/19 17:18 <br>
     *
     * @author haisong.liu
     */
    public static boolean isValidDate(String dateStr, String dataFormat) {
        boolean convertSuccess = true;
        SimpleDateFormat format = new SimpleDateFormat(dataFormat);
        try {
            format.setLenient(false);
            format.parse(dateStr);
        } catch (ParseException e) {
            convertSuccess = false;
        }
        return convertSuccess;
    }
    
    /**
     * 获取这一天的起始时间
     * <B>Description:</B> <br>
     * <B>Create on:</B> 2019年10月24日 下午4:44:14<br>
     *
     * @param date
     * @return 
     * @author yingjie.shen
     */
    public static Date getDayStartDate(Date date) {
        if (date == null) {
            return null;
        }
        String dateStr = format(date, FORMAT_SHORT);
        return parse(dateStr, FORMAT_SHORT);
    }
    
    /**
     * 获取这一天的结束时间
     * <B>Description:</B> <br>
     * <B>Create on:</B> 2019年10月24日 下午4:44:27<br>
     *
     * @param date
     * @return 
     * @author yingjie.shen
     */
    public static Date getDayEndDate(Date date) {
        if (date == null) {
            return null;
        }
        Date dayStart = getDayStartDate(date);
        return new Date(dayStart.getTime() + 24L*60L*60L*1000L - 1L);
    }
    
    public static boolean isDate(SimpleDateFormat sdf, String date) {
		try {
			sdf.parse(date);
			return true;
		} catch (ParseException e) {
			return false;
		}
	}
    
    public static Date parse(SimpleDateFormat sdf, String source) {
    	try {
			return sdf.parse(source);
		} catch (ParseException e) {
			return null;
		}
    }
}
